Modern automated processes such as manufacturing processes are implemented under strict and generally highly complex control regimes both to maximise efficiency and avoid error or failure. In their simplest form these regimes are typically based on a feedback system whereby a parameter of the process is monitored and fed to a controller as a control parameter for comparison with a target value, the state of the process being altered as a function of the control parameter to track the target value.
One known and widely adopted control regime is model predictive control (MPC) which is described in “Model Predictive Control; past, present and future.” Morari, M. and J. H. Lee (1999) Comput. Chem. Engng. 23, 667-682 which is incorporated herein by reference. The basic principle is illustrated in FIG. 1, adapted from Prett, D. M. and Garcia C. E. (1988) “Fundamental Process Control”, Butterworth Publishers, Boston. Using MPC, whilst the aim remains to track a target value, the controller at each control point—usually at discrete time intervals, not only monitors the existing state of the process, system or plant but estimates the state of the process at some point in the future, for example at the next time interval. References to control of a process in the following discussion can apply equally to plant or system control as appropriate.
Referring to FIG. 1, at a time t=k the current state is measured at point xk and its future states xk+1 to xk+p are estimated for corresponding future times t=k to t=k+p. As can be seen the aim is for the value x to track a target value xtarget. The control variable ut is similarly varied with time, its value for the next time increment being updated as the predicted state value is updated. As a result the system takes into account the effect that the current control variable will have on future states and accommodates that accordingly. The forward projection is carried out for a finite future period which is shifted forward incrementally at each measurement interval, termed a moving horizon policy.
This operation is carried out on-line and in real time, and is illustrated in FIG. 2. MPC operates by solving an optimization problem at each time interval based on measurements 10 from the process or plant 12 at that time. An optimiser 14 includes a process or plant model used to estimate the future behavior of the plant and an objective function to determine the optimal control strategy, ie variation of the control variable or corrective action 16, to reach the desired target.
Mathematically, the process or plant model can be represented, in state-space, by the equations:{x(t+1)=Ax(t)+Bu(t){y(t)=Cx(t),  (1)ymin≦y(t)≦ymaxumin≦u(t)≦umax  (2)u represents the control variables or process inputs manipulated by the controller to control the process, x the process states, ie measured values representative of the current values of one or more process variables and y the process output measurements. For multi variable processes, x, y and u are of course vectors and A and B matrices. The output and control variables are bounded by the min and max values forming constraints on the process.
The equations represent mathematically how at a time t in a process the future state of the process at a discrete, subsequent time interval t+1 is predicted as a function of the measured state x at time t and the control variables applied at time t—this calculation is then iterated forward, still at time t, for the predicted state at time t+2 based on the calculation for time t+1 and so forth. At time t, in addition, the process output is a direct function of the instantaneous process state. The process output is calculated at equation (2) to ensure it does not exceed the ouput constraints.
It has been shown that the iteration up to a time t+Ny can be posed in the form of the following problem to be optimised (for example, see Morari and Lee paper identified above):
                                                        min              U                        ⁢                                                  ⁢                          J              ⁡                              (                                  U                  ,                                      x                    ⁡                                          (                      t                      )                                                                      )                                              =                                                    x                                  1                  +                  Ny                                            ⁢                                                                                      Px                                          t                      +                      Ny                                                                                  t                                                                                          t                                      +                                                  ⁢                                          ∑                                  k                  =                  0                                                  Ny                  -                  1                                            ⁢                              (                                                                            x                                              t                        +                        k                                            ′                                        ⁢                                                                                                                      t                                                ⁢                                                  Qx                                                      t                            +                            k                                                                                                                      t                                                        +                                                            u                                              t                        +                        k                                            ′                                        ⁢                                          Ru                                              t                        +                        k                                                                                            )                                                    ⁢                                  ⁢                                  ⁢                                                            subject                ⁢                                                                  ⁢                to                ⁢                                                                  ⁢                                  y                  min                                            ≤                              y                                  t                  +                  k                                                      ⁢                          ❘              t                        ⁢                          ≤                              y                max                                              ,                      k            =            1                    ,          …          ⁢                                          ,                      N            c                          ⁢                                  ⁢                                  ⁢                                            u              min                        ≤                          u                              t                +                k                                      ≤                          u              max                                ,                      k            =                          0              ,              1                                ,          …          ⁢                                          ,                      N            c                          ⁢                                  ⁢                                  ⁢                                            x              t                        ⁢                          ❘              t                                =                      x            ⁡                          (              t              )                                      ⁢                                  ⁢                                  ⁢                                                            x                                  t                  +                  k                  +                  1                                            ⁢                                                                                        t                                    ⁢                                      =                                          Ax                                              t                        +                        k                                                                                                              t                                      +                          Bu                              t                +                k                                              ,                      k            ≥            0                          ⁢                                  ⁢                                  ⁢                                            y                              t                +                k                                      ⁢                                                                              t                                ⁢                                  =                                      Cx                                          t                      +                      k                                                                                                  t                                ,                      k            ≥            0                          ⁢                                  ⁢                                  ⁢                                            u                              t                +                k                                      =                                          Kx                                  t                  +                  k                                            ⁢                              ❘                t                                              ,                                    N              u                        ≤            k            ≤                          N              y                                                          (        3        )            where UΔ{ut, . . . , ut+Nu−1}, Q=Q′0, R=R′0, P0, Ny≧Nu, and K is some feedback gain. The problem (3) is solved repetitively at each time t for the current measurement x(t) and the vector of predicted state variables, xt+1|t, . . . , xt+k|t at time t+1, . . . , t+k respectively and corresponding control actions ut, . . . , ut+k−1 is obtained.
Equation (3) is the iterated expansion of equation (1). The first term on the right hand comprises a quadratic function of the predicted state variables at time t+Ny, using the vector transpose x′ and constant matrix P. The second term is a summation of all the intermediate predicted state variables from time t to time t+Ny−1 using the vector transpose x′ and constant matrix Q and, over the same range, of corresponding control variables u again in quadratic form with constant matrix R. In both cases each successive state value xt+k+1 is derived from the previous state value x1+k using equation 1. Each value of ut+k is derived as a function of the predicted state value for that time and gain matrix K. The constraints for y and u are controlled up to a time Nc. The function J is thus constructed.
The left hand side of equation (3) requires that an optimal solution is selected from the solution space by minimising the function J of the state x(t) and the vector U of control/input variables for all time intervals. The function J is minimised in control variable space, that is, the optimal value of U is found satisfying equation (3) including the various conditions in the “subject to” field such that J is minimum. The resulting values of u(t) and x(t) are then representable as shown in FIG. 1. The manner in which a real control situation can be represented as an MPC problem will be well known to the skilled person.
A significant problem arises in practical implementation of MPC as the processing power required for real time calculation is extremely high. Certainly if a large number of variables are required, complex control functions needed for complex processes or extremely short time intervals are desired, the burden can become cost, energy or even space inefficient. In addition, as the solution is created on-line and tailored only to instantaneous conditions, it provides no quantitative data on whether the model itself is appropriate.
Various attempts have been made to improve MPC implementation. For example in U.S. Pat. No. 6,056,781 to Wassick et al, in addition to a plant or process model, a disturbance model represents deviations from the plant model. In this version, if anything, the real time processing burden is enhanced. U.S. Pat. No. 5,347,446 to Iino et al describes a system taking into account constraints on the input or manipulated variables as well as constraints on controlled variables and change rates of the controlled variables. Again, the processing burden remains a significant concern.
U.S. Pat. No. 6,064,809 to Braatz et. al. addresses the problem of processing burden by approximating off-line the constraint set, that is; the limits or constraints on the input or manipulated variables as a mathematical construct off-line, in the form of an iteratively derived ellipsoid, effectively providing a simplified replacement for equation 3 above. However this simplified construct is then no more than an approximation which is scaled and then solved on-line in conventional MPC fashion. Accordingly Braatz et al. approached the problem by improving or simplifying the modeling process, but still requires significant on-line computational power.